{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "titre",
      "metadata": [],
      "source": [
        "# Devoir maison — Parcours séquentiel\n",
        "\n",
        "**Première NSI**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "consignes",
      "metadata": [],
      "source": [
        "## Consignes\n",
        "\n",
        "- Répondez aux questions dans les cellules prévues.\n",
        "- Complétez les cellules de code en remplaçant `pass`.\n",
        "- Écrivez les recherches et les calculs avec des boucles `for`. Vous pouvez parcourir les éléments directement ou utiliser leurs indices.\n",
        "- Les fonctions `sum`, `min`, `max`, `sorted` et les méthodes `index`, `count` ne doivent pas être utilisées.\n",
        "- Les fonctions écrites doivent conserver le contenu des tableaux reçus en paramètres.\n",
        "- Exécutez les tests après avoir écrit chaque réponse. Les tests utilisent uniquement des `assert` : si aucune erreur ne s'affiche, ils sont réussis.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ex1-enonce",
      "metadata": [],
      "source": [
        "## Exercice 1 — Comprendre un parcours\n",
        "\n",
        "On considère le programme suivant :\n",
        "\n",
        "```python\n",
        "valeurs = [6, 2, 9, 2, 5]\n",
        "total = 0\n",
        "for i in range(len(valeurs)):\n",
        "    if valeurs[i] >= 5:\n",
        "        total = total + valeurs[i]\n",
        "```\n",
        "\n",
        "### 1. Suivre l'exécution\n",
        "\n",
        "Sans exécuter le programme, complétez le tableau ci-dessous. La dernière colonne donne la valeur de `total` à la fin de chaque tour de boucle.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ex1-reponse1",
      "metadata": [],
      "source": [
        "| Indice `i` | Élément `valeurs[i]` | `total` à la fin du tour |\n",
        "| --- | --- | --- |\n",
        "| 0 | ... | ... |\n",
        "| 1 | ... | ... |\n",
        "| 2 | ... | ... |\n",
        "| 3 | ... | ... |\n",
        "| 4 | ... | ... |\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ex1-question2",
      "metadata": [],
      "source": [
        "### 2. Changer la façon de parcourir le tableau\n",
        "\n",
        "Réécrivez ce programme en parcourant directement les éléments avec `for valeur in valeurs`. Le résultat doit être identique.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex1-code2",
      "metadata": [],
      "source": [
        "valeurs = [6, 2, 9, 2, 5]\n",
        "total = 0\n",
        "pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex1-tests-titre",
      "metadata": [],
      "source": [
        "**Test**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex1-tests",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert total == 20\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex2-enonce",
      "metadata": [],
      "source": [
        "## Exercice 2 — Rechercher et compter une valeur\n",
        "\n",
        "Les fonctions de cet exercice doivent fonctionner avec des tableaux de nombres ou de chaînes de caractères. Le tableau peut être vide.\n",
        "\n",
        "### 1. Première occurrence\n",
        "\n",
        "Écrivez la fonction `rechercher(tableau, valeur)` qui renvoie l'indice de la **première occurrence** de `valeur` dans `tableau`.\n",
        "\n",
        "Si la valeur est absente, la fonction renvoie `-1`.\n",
        "\n",
        "Par exemple, `rechercher([6, 2, 9, 2, 5], 2)` doit renvoyer `1`.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex2-code1",
      "metadata": [],
      "source": [
        "def rechercher(tableau, valeur):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex2-tests1-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex2-tests1",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert rechercher([6, 2, 9, 2, 5], 2) == 1\n",
        "assert rechercher([6, 2, 9, 2, 5], 6) == 0\n",
        "assert rechercher([6, 2, 9, 2, 5], 5) == 4\n",
        "assert rechercher([6, 2, 9, 2, 5], 8) == -1\n",
        "assert rechercher([\"Lina\", \"Noé\", \"Lina\"], \"Lina\") == 0\n",
        "assert rechercher([\"Lina\", \"Noé\", \"Lina\"], \"Adam\") == -1\n",
        "assert rechercher([], 2) == -1\n",
        "assert rechercher([4], 4) == 0\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex2-question2",
      "metadata": [],
      "source": [
        "### 2. Nombre d'occurrences\n",
        "\n",
        "Écrivez la fonction `compter_occurrences(tableau, valeur)` qui renvoie le nombre de fois où `valeur` apparaît dans `tableau`.\n",
        "\n",
        "Par exemple, `compter_occurrences([6, 2, 9, 2, 5], 2)` doit renvoyer `2`.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex2-code2",
      "metadata": [],
      "source": [
        "def compter_occurrences(tableau, valeur):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex2-tests2-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex2-tests2",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert compter_occurrences([6, 2, 9, 2, 5], 2) == 2\n",
        "assert compter_occurrences([6, 2, 9, 2, 5], 8) == 0\n",
        "assert compter_occurrences([4, 4, 4], 4) == 3\n",
        "assert compter_occurrences([\"Lina\", \"Noé\", \"Lina\"], \"Lina\") == 2\n",
        "assert compter_occurrences([], 2) == 0\n",
        "assert compter_occurrences([4], 4) == 1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex3-enonce",
      "metadata": [],
      "source": [
        "## Exercice 3 — Rechercher des extrema\n",
        "\n",
        "Dans cet exercice, les tableaux contiennent des nombres et sont **non vides**.\n",
        "\n",
        "### 1. Minimum et maximum\n",
        "\n",
        "Écrivez la fonction `extrema(tableau)` qui renvoie le couple `(minimum, maximum)`.\n",
        "\n",
        "Les deux valeurs doivent être recherchées pendant **un seul parcours** du tableau.\n",
        "\n",
        "Par exemple, `extrema([6, 2, 9, 2, 5])` doit renvoyer `(2, 9)`.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex3-code1",
      "metadata": [],
      "source": [
        "def extrema(tableau):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex3-tests1-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex3-tests1",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert extrema([6, 2, 9, 2, 5]) == (2, 9)\n",
        "assert extrema([-9, -2, -7]) == (-9, -2)\n",
        "assert extrema([5]) == (5, 5)\n",
        "assert extrema([4, 4, 4]) == (4, 4)\n",
        "assert extrema([3.5, -1.5, 2.5]) == (-1.5, 3.5)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex3-question2",
      "metadata": [],
      "source": [
        "### 2. Indice du premier maximum\n",
        "\n",
        "Écrivez la fonction `indice_maximum(tableau)` qui renvoie l'indice du plus grand élément.\n",
        "\n",
        "Si le maximum apparaît plusieurs fois, la fonction doit renvoyer l'indice de sa **première occurrence**.\n",
        "\n",
        "Par exemple, `indice_maximum([4, 9, 2, 9])` doit renvoyer `1`.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex3-code2",
      "metadata": [],
      "source": [
        "def indice_maximum(tableau):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex3-tests2-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex3-tests2",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert indice_maximum([4, 9, 2, 9]) == 1\n",
        "assert indice_maximum([7, 4, 7]) == 0\n",
        "assert indice_maximum([-9, -2, -2, -7]) == 1\n",
        "assert indice_maximum([5]) == 0\n",
        "assert indice_maximum([2, 9, 4]) == 1\n",
        "assert indice_maximum([4, 4, 4]) == 0\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-enonce",
      "metadata": [],
      "source": [
        "## Exercice 4 — Une semaine de températures\n",
        "\n",
        "On a relevé les températures suivantes, en degrés Celsius, pendant sept jours :\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-donnees",
      "metadata": [],
      "source": [
        "temperatures = [12, 14, 10, 16, 13, 11, 15]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-question1",
      "metadata": [],
      "source": [
        "### 1. Calculer une moyenne\n",
        "\n",
        "Écrivez la fonction `moyenne(tableau)` qui renvoie la moyenne des nombres du tableau.\n",
        "\n",
        "Le tableau est **non vide**. La fonction doit fonctionner pour n'importe quel nombre d'éléments.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-code1",
      "metadata": [],
      "source": [
        "def moyenne(tableau):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-tests1-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-tests1",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert moyenne(temperatures) == 13.0\n",
        "assert moyenne([2, 4, 6]) == 4.0\n",
        "assert moyenne([7]) == 7.0\n",
        "assert moyenne([-6, -3, -9]) == -6.0\n",
        "assert moyenne([1, 2]) == 1.5\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-question2",
      "metadata": [],
      "source": [
        "### 2. Compter les valeurs au-dessus de la moyenne\n",
        "\n",
        "Écrivez la fonction `nombre_au_dessus_moyenne(tableau)` qui renvoie le nombre d'éléments **strictement supérieurs** à la moyenne du tableau.\n",
        "\n",
        "Le tableau est **non vide**.\n",
        "\n",
        "Appelez la fonction `moyenne` une seule fois, avant la boucle de comptage, et conservez son résultat dans une variable.\n",
        "\n",
        "Pour la semaine donnée, la fonction doit renvoyer `3`.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-code2",
      "metadata": [],
      "source": [
        "def nombre_au_dessus_moyenne(tableau):\n",
        "    pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-tests2-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-tests2",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert nombre_au_dessus_moyenne(temperatures) == 3\n",
        "assert nombre_au_dessus_moyenne([5, 5, 5]) == 0\n",
        "assert nombre_au_dessus_moyenne([7]) == 0\n",
        "assert nombre_au_dessus_moyenne([-6, -3, -9]) == 1\n",
        "assert nombre_au_dessus_moyenne([1, 3]) == 1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-question3",
      "metadata": [],
      "source": [
        "### 3. Construire un tableau en compréhension\n",
        "\n",
        "Calculez la moyenne de `temperatures` et stockez-la dans `moyenne_semaine`.\n",
        "\n",
        "Construisez ensuite **par compréhension** le tableau `ecarts`. Chaque élément doit être la température du jour moins la moyenne de la semaine, dans le même ordre que les températures.\n",
        "\n",
        "Un écart négatif correspond à une température inférieure à la moyenne.\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-code3",
      "metadata": [],
      "source": [
        "pass\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "ex4-tests3-titre",
      "metadata": [],
      "source": [
        "**Tests**\n"
      ]
    },
    {
      "cell_type": "code",
      "id": "ex4-tests3",
      "metadata": {
        "tags": [
          "tests"
        ]
      },
      "source": [
        "assert moyenne_semaine == 13.0\n",
        "assert ecarts == [-1, 1, -3, 3, 0, -2, 2]\n",
        "assert len(ecarts) == len(temperatures)\n",
        "assert temperatures == [12, 14, 10, 16, 13, 11, 15]\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "pygments_lexer": "ipython3",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      }
    },
    "dm": {
      "niveau": "Première NSI",
      "corrige": false,
      "sources": [
        {
          "fichier": "Untitd.ipynb",
          "titre": "Algorithmique — Parcours séquentiel d’un tableau"
        },
        {
          "fichier": "Untitled.ipynb",
          "titre": "Représentation des données — Tableau indexé, tableau donné en compréhension"
        }
      ]
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}